package com.jsy.goods.service.impl;

import com.alibaba.fastjson.JSON;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.jsy.common.util.IdWorker;

import com.jsy.goods.dao.BrandMapper;
import com.jsy.goods.dao.CategoryMapper;
import com.jsy.goods.dao.SkuMapper;
import com.jsy.goods.dao.SpuMapper;
import com.jsy.goods.pojo.*;

import com.jsy.goods.service.SpuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import tk.mybatis.mapper.entity.Example;

import java.util.Arrays;
import java.util.Date;
import java.util.List;
import java.util.Map;

/****
 * @Author:www.jsy.com
 * @Description:Spu业务层接口实现类
 * @Date jsy
 *****/
@Service
public class SpuServiceImpl implements SpuService {

    @Autowired
    private SpuMapper spuMapper;

    @Autowired
    private SkuMapper skuMapper;

    @Autowired
    private BrandMapper brandMapper;

    @Autowired
    private CategoryMapper categoryMapper;

    @Autowired
    private IdWorker idWorker;
    /**
     * Spu条件+分页查询
     * @param spu 查询条件
     * @param page 页码
     * @param size 页大小
     * @return 分页结果
     */
    @Override
    public PageInfo<Spu> findPage(Spu spu, int page, int size){
        //分页
        PageHelper.startPage(page,size);
        //搜索条件构建
        Example example = createExample(spu);
        //执行搜索
        return new PageInfo<Spu>(spuMapper.selectByExample(example));
    }

    /**
     * Spu分页查询
     * @param page
     * @param size
     * @return
     */
    @Override
    public PageInfo<Spu> findPage(int page, int size){
        //静态分页
        PageHelper.startPage(page,size);
        //分页查询
        return new PageInfo<Spu>(spuMapper.selectAll());
    }

    /**
     * Spu条件查询
     * @param spu
     * @return
     */
    @Override
    public List<Spu> findList(Spu spu){
        //构建查询条件
        Example example = createExample(spu);
        //根据构建的条件查询数据
        return spuMapper.selectByExample(example);
    }


    /**
     * Spu构建查询对象
     * @param spu
     * @return
     */
    public Example createExample(Spu spu){
        Example example=new Example(Spu.class);
        Example.Criteria criteria = example.createCriteria();
        if(spu!=null){
            // 主键
            if(!StringUtils.isEmpty(spu.getId())){
                    criteria.andEqualTo("id",spu.getId());
            }
            // 货号
            if(!StringUtils.isEmpty(spu.getSn())){
                    criteria.andEqualTo("sn",spu.getSn());
            }
            // SPU名
            if(!StringUtils.isEmpty(spu.getName())){
                    criteria.andLike("name","%"+spu.getName()+"%");
            }
            // 副标题
            if(!StringUtils.isEmpty(spu.getCaption())){
                    criteria.andEqualTo("caption",spu.getCaption());
            }
            // 品牌ID
            if(!StringUtils.isEmpty(spu.getBrandId())){
                    criteria.andEqualTo("brandId",spu.getBrandId());
            }
            // 一级分类
            if(!StringUtils.isEmpty(spu.getCategory1Id())){
                    criteria.andEqualTo("category1Id",spu.getCategory1Id());
            }
            // 二级分类
            if(!StringUtils.isEmpty(spu.getCategory2Id())){
                    criteria.andEqualTo("category2Id",spu.getCategory2Id());
            }
            // 三级分类
            if(!StringUtils.isEmpty(spu.getCategory3Id())){
                    criteria.andEqualTo("category3Id",spu.getCategory3Id());
            }
            // 模板ID
            if(!StringUtils.isEmpty(spu.getTemplateId())){
                    criteria.andEqualTo("templateId",spu.getTemplateId());
            }
            // 运费模板id
            if(!StringUtils.isEmpty(spu.getFreightId())){
                    criteria.andEqualTo("freightId",spu.getFreightId());
            }
            // 图片
            if(!StringUtils.isEmpty(spu.getImage())){
                    criteria.andEqualTo("image",spu.getImage());
            }
            // 图片列表
            if(!StringUtils.isEmpty(spu.getImages())){
                    criteria.andEqualTo("images",spu.getImages());
            }
            // 售后服务
            if(!StringUtils.isEmpty(spu.getSaleService())){
                    criteria.andEqualTo("saleService",spu.getSaleService());
            }
            // 介绍
            if(!StringUtils.isEmpty(spu.getIntroduction())){
                    criteria.andEqualTo("introduction",spu.getIntroduction());
            }
            // 规格列表
            if(!StringUtils.isEmpty(spu.getSpecItems())){
                    criteria.andEqualTo("specItems",spu.getSpecItems());
            }
            // 参数列表
            if(!StringUtils.isEmpty(spu.getParaItems())){
                    criteria.andEqualTo("paraItems",spu.getParaItems());
            }
            // 销量
            if(!StringUtils.isEmpty(spu.getSaleNum())){
                    criteria.andEqualTo("saleNum",spu.getSaleNum());
            }
            // 评论数
            if(!StringUtils.isEmpty(spu.getCommentNum())){
                    criteria.andEqualTo("commentNum",spu.getCommentNum());
            }
            // 是否上架
            if(!StringUtils.isEmpty(spu.getIsMarketable())){
                    criteria.andEqualTo("isMarketable",spu.getIsMarketable());
            }
            // 是否启用规格
            if(!StringUtils.isEmpty(spu.getIsEnableSpec())){
                    criteria.andEqualTo("isEnableSpec",spu.getIsEnableSpec());
            }
            // 是否删除
            if(!StringUtils.isEmpty(spu.getIsDelete())){
                    criteria.andEqualTo("isDelete",spu.getIsDelete());
            }
            // 审核状态
            if(!StringUtils.isEmpty(spu.getStatus())){
                    criteria.andEqualTo("status",spu.getStatus());
            }
        }
        return example;
    }
    /**
     * 修改Spu
     * @param spu
     */
    @Override
    public Integer update(Spu spu){
        return spuMapper.updateByPrimaryKey(spu);
    }

    /**
     * 增加Spu
     * @param spu
     */
    @Override
    public Integer add(Spu spu) {
        return spuMapper.insertSelective(spu);
    }

    /**
     * 根据ID查询Spu
     * @param id
     * @return
     */
    @Override
    public Spu findById(Long id){
        return  spuMapper.selectByPrimaryKey(id);
    }

    /**
     * 查询Spu全部数据
     * @return
     */
    @Override
    public List<Spu> findAll() {
        return spuMapper.selectAll();
    }


    /**
     * 增加Spu Sku
     * @param goods
     */
    @Override
    public Integer saveGoods(Goods goods) {
        /* 合并增加、修改货物方法，只需判断是否存在id */
        //保存货物分为两个步骤spu sku
        // 1.保存数据到SPU标准产品单位表
        Spu spu = goods.getSpu();
        //设置审核状态
        spu.setStatus("0");
        //设置id（非自增主键，便于数据表的迁移，但需要手动设置，使用工具生成）
        int count=0;
        if (spu.getId()==null){
            //新增
            spu.setId(idWorker.nextId());
             count = spuMapper.insertSelective(spu);
        }else {
            //修改；更新spu
            spuMapper.updateByPrimaryKey(spu);
            //修改spu时会增加sku列表的信息，所以需要删除
            Sku sku = new Sku();
            sku.setSpuId(spu.getId());
            skuMapper.delete(sku);
        }
        // 2.保存数据到SKU标准库存单位表
        //设置sku列表的其他属性
        List<Sku> skuList = goods.getSkuList();
        if (skuList!=null&&skuList.size()>0) {
            for (Sku sku : skuList) {
                //名称=spu名称+所有规格选项的值
                String name=spu.getName();
                //获取所有规格,规格使用json字符串存储便于修改
                if (!StringUtils.isEmpty(sku.getSpec())){
                    //拼接规格需要解析转换成mapper再拼接
                    Map<String,String> map = JSON.parseObject(sku.getSpec(), Map.class);
                    //遍历map获得所有值
                    for (Map.Entry<String ,String> entry : map.entrySet()){
                        name+=" "+entry.getValue();
                    }
                }else {
                    //设置空规格对象
                    sku.setSpec("{}");
                }
                sku.setName(name);
                //id
                sku.setId(idWorker.nextId());
                //设置spuId
                sku.setSpuId(spu.getId());
                //设置品牌
                Brand brand = brandMapper.selectByPrimaryKey(spu.getBrandId());
                sku.setBrandName(brand.getName());
                //设置分类
                Category category = categoryMapper.selectByPrimaryKey(spu.getCategory3Id());
                sku.setCategoryId(category.getId());
                sku.setCategoryName(category.getName());
                //设置创建时间与更新时间
                sku.setCreateTime(new Date());
                sku.setUpdateTime(sku.getCreateTime());
                //设置审核状态
                sku.setStatus("0");
                 count+= skuMapper.insertSelective(sku);
            }
        }
        return count;
    }

    @Override
    public Goods findGoodsBySpuId(Long spuId) {
        //需要分两个步骤spu sku
        Goods goods = new Goods();
        //设置spu 可以直接使用findById()
        Spu spu = findById(spuId);
        goods.setSpu(spu);
        //设置sku
        Sku sku = new Sku();
        sku.setSpuId(spuId);
        List<Sku> skuList = skuMapper.select(sku);
        goods.setSkuList(skuList);
        return goods;
    }

    /***
     * 修改审核状态
     * @param id 商品spu id
     * @return 审核结果
     */
    @Override
    public Integer audit(Long id) {
        //查看状态
        Spu spu = spuMapper.selectByPrimaryKey(id);
        //设置状态
        if ("1".equals(spu.getIsDelete())){
            throw new RuntimeException("商品已经被删除");
        }else {
            //审核
            spu.setStatus("1");
            //上架
            spu.setIsMarketable("1");
            return spuMapper.updateByPrimaryKey(spu);
        }
    }

    /***
     * 上架商品
     * @param id 商品spu id
     * @return 操作结果
     */
    @Override
    public Integer put(Long id) {
        Spu spu = spuMapper.selectByPrimaryKey(id);
        if ("1".equals(spu.getIsDelete())){
            throw new RuntimeException("商品已经被删除");
        }
        if ("0".equals(spu.getStatus())){
            throw new RuntimeException("审核通过之后才能上架");
        }
        //上架
        spu.setIsMarketable("1");
        return spuMapper.updateByPrimaryKey(spu);
    }

    /***
     * 批量上架商品
     * @param ids 商品spu id
     * @return 操作结果
     */
    @Override
    public Integer putMany(Long[] ids) {
        //为删除，已审核通过的才能上架
        Example example = new Example(Spu.class);
        Example.Criteria criteria = example.createCriteria();
        criteria.andEqualTo("isDelete","0");
        criteria.andEqualTo("status","1");
        criteria.andIn("id", Arrays.asList(ids));
        //设置要更新的内容
        Spu spu = new Spu();
        spu.setIsMarketable("1");
        return spuMapper.updateByExample(spu,example);
    }


    /***
     * 下架商品
     * @param id 商品spu id
     * @return 操作结果
     */
    @Override
    public Integer pull(Long id) {
        Spu spu = findById(id);
        if ("1".equals(spu.getIsDelete())){
            throw new RuntimeException("商品已经被删除");
        }
        //未审核
        spu.setStatus("0");
        //下架
        spu.setIsMarketable("0");
        return spuMapper.updateByPrimaryKeySelective(spu);
    }

    /**
     * 还原删除商品
     * @param id 商品spu id
     * @return 操作结果
     */
    @Override
    public Integer restore(Long id) {
        Spu spu = findById(id);
        if ("0".equals(spu.getIsDelete())){
            throw new RuntimeException("商品未被删除，不需要还原");
        }
        spu.setStatus("0");
        spu.setIsMarketable("0");
        return spuMapper.updateByPrimaryKeySelective(spu);
    }

    /***
     * 物理删除goods数据
     * @param id 查看对象
     * @return 操作结果
     */
    @Override
    public Integer delete(Long id) {
        //删除数据库中的数据
        // 删除spu
        Spu spu = findById(id);
        //必须先逻辑删除
        if ("0".equals(spu.getIsDelete())){
            throw new RuntimeException("此商品不能删除");
        }
        //删除对应的sku
        Sku sku = new Sku();
        sku.setSpuId(id);
        int count = skuMapper.delete(sku);

         count += spuMapper.deleteByPrimaryKey(id);
        return count;
    }

    /***
     * 删除goods数据 逻辑删除
     * @param spuId 查看对象
     * @return 操作结果
     */
    @Override
    public Integer logicDelete(Long spuId) {
        //逻辑删除只需设置先下架再删除
        Spu spu = findById(spuId);
        if ("1".equals(spu.getIsDelete())){
            throw new RuntimeException("商品已经被删除");
        }
        if ("1".equals(spu.getIsMarketable())){
            throw new RuntimeException("商品要先下架才能删除");
        }
        //未审核
        spu.setIsMarketable("0");
        spu.setStatus("0");
        //设置已删除
        spu.setIsDelete("1");
        return spuMapper.updateByPrimaryKeySelective(spu);
    }
}
